sql.js ➔ cleanRequest - Code Metrics - Inspection of "bug on builderjs" - AdFabConnect/abejs - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 2115c9...bdfcbe )

unknown

created 2016-10-04 12:42 UTC

sql.js ➔ cleanRequest C

↳ Parent: src/cli/cms/data/sql.js

Complexity

Conditions	12
Paths	4

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	12
nc	4
dl	0
loc	46
rs	5.15
c	0
b	0
f	0
nop	2

How to fix Complexity

import {parse} from 'node-sqlparser'
import {Promise} from 'es6-promise'
import path from 'path'
import {
  config,
  Manager,
  FileParser,

  getAttr
} from '../../'

export function cleanRequest(str, jsonPage) {

  var matchFrom = /from .(.*?) /
  var matchVariable = /{{([a-zA-Z]*)}}/

  var matchFromExec = matchFrom.exec(str)
  if(typeof matchFromExec !== 'undefined' && matchFromExec !== null
    && typeof matchFromExec[1] !== 'undefined' && matchFromExec[1] !== null) {

    var fromMatch
    var toReplace = matchFromExec[1]
    while (fromMatch = matchVariable.exec(toReplace)) {
      try {
        var value = eval('jsonPage.' + fromMatch[1])

        if(typeof value !== 'undefined' && value !== null) {
          toReplace = toReplace.replace('{{' + fromMatch[1] + '}}', value)
        }else {
          toReplace = toReplace.replace('{{' + fromMatch[1] + '}}', '')
        }
      }catch(e) {

      }
    }

    str = str.replace(matchFromExec[1], toReplace)
  }

  var from = /from ([\S\s]+)/.exec(str)

  var matches = from
  if(matches[1]) {
    var res = matches[1]
    var splitAttr = [' where ', ' order by ', ' limit ', ' WHERE ', ' ORDER BY ', ' LIMIT ']
    for(var i = 0; i < splitAttr.length; i++) {
      if(res.indexOf(splitAttr[i]) > -1) {
        res = res.substring(0, res.indexOf(splitAttr[i]))
      }
    }
    var escapedFrom = res.replace(/\//g, '___abe___')
    escapedFrom = escapedFrom.replace(/\./g, '___abe_dot___')
    escapedFrom = escapedFrom.replace(/-/g, '___abe_dash___')
    str = str.replace(res, escapedFrom)
  }

  str = str.replace(/``/g, '\'\'')

  return str
}

export function handleSqlRequest(str, jsonPage) {
  var req = cleanRequest(str, jsonPage)
  var request = parse(req)
  var reconstructSql = ''

  // SQL TYPE
  var type = ''
  if(typeof request.type !== 'undefined' && request.type !== null) {
    type = request.type
  }
  reconstructSql += `${type} `

  // SQL COLUMNS
  var columns = []
  if(typeof request.columns !== 'undefined' && request.columns !== null) {
    if(request.columns === '*') {
      columns.push('*')
    }else {
      Array.prototype.forEach.call(request.columns, (item) => {
        columns.push(item.expr.column)
      })
    }
  }
  reconstructSql += `${JSON.stringify(columns)} `

  // SQL FROM
  var from = []
  if(typeof request.from !== 'undefined' && request.from !== null) {

    Array.prototype.forEach.call(request.from, (item) => {
      from.push(item.table)
    })
  }else {
    from.push('*')
  }
  reconstructSql += `from ${JSON.stringify(from)} `

  var where
  if(typeof request.where !== 'undefined' && request.where !== null) {
    where = request.where
    // where = recurseWhere(request.where)
    // reconstructSql += 'where '
    // Array.prototype.forEach.call(where, (w) => {
    //   reconstructSql += `${w.operator} ${w.left} ${w.compare} ${w.right} `
    // })
  }

  var limit = -1
  if(typeof request.limit !== 'undefined' && request.limit !== null) {
    limit = request.limit[request.limit.length - 1].value
  }

  var orderby
  if(typeof request.orderby !== 'undefined' && request.orderby !== null && request.orderby.length > 0) {
    orderby = {
      column: request.orderby[0].expr.column,
      type: request.orderby[0].type
    }
    reconstructSql += `ORDER BY ${orderby.column} ${orderby.type} `
  }

  return {
    type: type,
    columns: columns,
    from: from,
    where: where,

    string: reconstructSql,
    limit: limit,
    orderby: orderby

  }
}

export function sortByDateDesc(a, b) {
  var dateA = new Date(a.date)
  var dateB = new Date(b.date)
  if(dateA < dateB) {
    return 1
  }else if(dateA > dateB) {
    return -1
  }
  return 0
}

export function shuffle(array) {
  var currentIndex = array.length, temporaryValue, randomIndex

  // While there remain elements to shuffle...
  while (0 !== currentIndex) {

    // Pick a remaining element...
    randomIndex = Math.floor(Math.random() * currentIndex)
    currentIndex -= 1

    // And swap it with the current element.
    temporaryValue = array[currentIndex]
    array[currentIndex] = array[randomIndex]
    array[randomIndex] = temporaryValue
  }

  return array
}

export function sortByDateAsc(a, b) {
  var dateA = new Date(a.date)
  var dateB = new Date(b.date)
  if(dateA > dateB) {
    return 1
  }else if(dateA < dateB) {
    return -1
  }
  return 0
}

export function getDataSource(str) {
  var res = str.substring(str.indexOf('source=') + 8, str.length)

  var reg = /([^'"]*=[\s\S]*?}})/g
  var matches = res.match(reg)
  if(typeof matches !== 'undefined' && matches !== null) {
    Array.prototype.forEach.call(matches, (match) => {
      res = res.replace(match, '')
    })
  }else {
    res = res.replace('}}', '')
  }

  return res.substring(0, res.length-1)
}

/**
 * replaces escaped characters with the right ones
 * @param  {String} statement the from clause
 * @return {String}           the from sanitized
 */
export function sanitizeFromStatement(statement){
  var from = ''

  if(typeof statement !== 'undefined' && statement !== null) {
    from = statement[0].replace(/___abe_dot___/g, '.')
    from = from.replace(/___abe___/g, '/')
    from = from.replace(/___abe_dash___/g, '-')
  }

  return from
}

/**
 * calculate the directory to analyze from the from clause
 * @param  {String} statement the from clause
 * @param  {String} tplPath   the path from the template originator
 * @return {string}           the directory to analyze
 */
export function getFromDirectory(statement, tplPath){
  var pathFromDir = ''
  if(typeof tplPath === 'undefined' || tplPath === null || tplPath === ''){
    tplPath = '/'
  }

  if(statement === '' || statement === '*' || statement === '/') {
    pathFromDir = path.join(config.root, config.data.url)
  }else if(statement === './') {
    pathFromDir = path.join(config.root, config.data.url, tplPath)
  }else if(statement.indexOf('/') === 0) {
    pathFromDir = path.join(config.root, config.data.url, statement)
  }else if(statement.indexOf('/') !== 0) {
    pathFromDir = path.join(config.root, config.data.url, tplPath, statement)
  }

  return pathFromDir
}

export function executeOrderByClause(files, orderby){
  if(typeof orderby !== 'undefined' && orderby !== null) {
    if(orderby.column.toLowerCase() === 'random') {
      shuffle(files)
    }else if(orderby.column.toLowerCase() === 'date') {
      if(orderby.type === 'ASC') {
        files.sort(sortByDateAsc)
      }else if(orderby.type === 'DESC') {
        files.sort(sortByDateDesc)
      }
    }
  }

  return files
}

export function executeFromClause(statement, pathFromClause){
  var from = sanitizeFromStatement(statement)

  // if the from clause ends with a dot, we won't recurse the directory analyze
  if(from.slice(-1) === '.'){
    from = from.slice(0, -1)
  }
  
  var fromDirectory = getFromDirectory(from, pathFromClause)

  var list = Manager.instance.getList()
  var files_array = list.filter((element, index) => {

    if(element.publish) {
      if (element.path.indexOf(fromDirectory) > -1) {
        return true
      }
    }
    return false
  })
  return files_array
}

export function execQuery(pathQuery, match, jsonPage) {
  var res
  var files
  var request = handleSqlRequest(getAttr(match, 'source'), jsonPage)

  files = executeFromClause(request.from, pathQuery)
  files = executeOrderByClause(files, request.orderby)
  res = executeWhereClause(files, request.where, request.limit, request.columns, jsonPage)

  return res
}

export function executeQuerySync(pathQuerySync, match, jsonPage) {
  return execQuery(pathQuerySync, match, jsonPage)
}

export function executeQuery(pathexecuteQuery, match, jsonPage) {
  var p = new Promise((resolve) => {
    var res = execQuery(pathexecuteQuery, match, jsonPage)
    resolve(res)
  }).catch(function(e) {
    console.error(e)
  })

  return p
}

/**
 * check if a given string an url, string json, file url, abe sql request
 * 
 * get('http://google.com')
 * get('{"test":"test"}')
 * get('select * from ../')
 * get('test')
 * 
 * @param  {String} str 
 * @return {String} url | request | value | file | other
 */
export function getSourceType(str) {
  if(/http:\/\/|https:\/\//.test(str)) {
    return 'url'
  }

  if(/select[\S\s]*?from/.test(str)) {
    return 'request'
  }

  try {
    JSON.parse(str)
    return 'value'
  }catch(e) {


  }

  if(/\.json/.test(str)) {
    return 'file'
  }

  return 'other'
}

export function executeWhereClause(files, wheres, maxLimit, columns, jsonPage){
  var res = []
  var limit = 0

  for(let file of files) {
    if(limit < maxLimit || maxLimit === -1) {
      if(typeof wheres !== 'undefined' && wheres !== null) {

        if(!recurseWhere(wheres, file.publish, jsonPage)) {
          var json = JSON.parse(JSON.stringify(file.publish))
          var jsonValues = {}

          if(typeof columns !== 'undefined' && columns !== null && columns.length > 0 && columns[0] !== '*') {
            
            Array.prototype.forEach.call(columns, (column) => {
              if(typeof json[column] !== 'undefined' && json[column] !== null) {

                jsonValues[column] = json[column]

              }
            })
            jsonValues['abe_meta'] = json['abe_meta']
          }else {
            jsonValues = json
          }

          res.push(jsonValues)
          limit++
        }
      }
    } else {
      break
    }
  }

  return res
}

export function getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc) {

  var regexIsVariable = /^{{(.*)}}$/
  var value
  var compare

  try {
    var variableLeft = where.left.column
    var checkIfLeftIsAVariable = regexIsVariable.exec(variableLeft)
    if(typeof checkIfLeftIsAVariable !== 'undefined' && checkIfLeftIsAVariable !== null && checkIfLeftIsAVariable.length > 0) {
      variableLeft = checkIfLeftIsAVariable[1]
    }
    value = eval('jsonDoc.' + variableLeft)

  }catch(e) {
    // console.log('e', e)
  }
  
  if(where.operator === 'IN' || where.operator === 'NOT IN') {
    compare = []
    Array.prototype.forEach.call(where.right.value, (right) => {
      var matchRightVariable = regexIsVariable.exec(right.column)
      if(typeof matchRightVariable !== 'undefined' && matchRightVariable !== null && matchRightVariable.length > 0) {
        try {
          var jsonOriginalValues = eval('jsonOriginalDoc.' + matchRightVariable[1])

          Array.prototype.forEach.call(jsonOriginalValues, (jsonOriginalValue) => {

            compare.push(eval('jsonOriginalValue.' + where.left.column))

          })
        }catch(e) {}

      }
      else{
        compare.push(right.column)
      }
    })
  }else {
    compare = where.right.column
    var matchRightVariable = regexIsVariable.exec(compare)

    if(typeof matchRightVariable !== 'undefined' && matchRightVariable !== null && matchRightVariable.length > 0) {
      try {
        var shouldCompare = eval('jsonOriginalDoc.' + matchRightVariable[1])

        if(typeof shouldCompare !== 'undefined' && shouldCompare !== null) {
          compare = shouldCompare
        }else {
          compare = null
        }
      }catch(e) {
        compare = null
      }
    }
  }

  return {
    left: value,

    right: compare
  }
}

export function recurseWhere(where, jsonDoc, jsonOriginalDoc) {
  var shouldAdd = true

  var isNotLeftCorrect = false

  var isNotRightCorrect = false

  var isNotCorrect = false


  switch(where.operator) {

  case '=':
    var values = getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc)
    isNotCorrect = !(values.left === values.right)
    break
  case '!=':
    var values = getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc)

    isNotCorrect = !(values.left !== values.right)
    break
  case '>':
    var values = getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc)

    isNotCorrect = !(values.left > values.right)
    break
  case '>=':
    var values = getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc)

    isNotCorrect = !(values.left >= values.right)
    break
  case '<':
    var values = getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc)

    isNotCorrect = !(values.left < values.right)
    break
  case '<=':
    var values = getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc)

    isNotCorrect = !(values.left <= values.right)
    break
  case 'LIKE':
    var values = getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc)

    isNotCorrect = !(values.left && values.left.indexOf(values.right) > -1)
    break
  case 'NOT LIKE':
    var values = getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc)

    isNotCorrect = !(values.left && values.left.indexOf(values.right) === -1)
    break
  case 'AND':
    isNotLeftCorrect = recurseWhere(where.left, jsonDoc, jsonOriginalDoc)
    isNotRightCorrect = recurseWhere(where.right, jsonDoc, jsonOriginalDoc)
    isNotCorrect = (isNotLeftCorrect || isNotRightCorrect) ? true : false
    break
  case 'OR':
    isNotLeftCorrect = recurseWhere(where.left, jsonDoc, jsonOriginalDoc)
    isNotRightCorrect = recurseWhere(where.right, jsonDoc, jsonOriginalDoc)
    isNotCorrect = (isNotLeftCorrect && isNotRightCorrect) ? true : false
    break
  case 'IN':
    var values = getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc)

    isNotCorrect = true
    Array.prototype.forEach.call(values.right, (right) => {
      if(values.left === right) {
        isNotCorrect = false
      }
    })
    break
  case 'NOT IN':
    var values = getWhereValuesToCompare(where, jsonDoc, jsonOriginalDoc)

    isNotCorrect = false
    Array.prototype.forEach.call(values.right, (right) => {
      if(values.left === right) {
        isNotCorrect = true
      }
    })
    break
  }
  return isNotCorrect
}

1			import {parse} from 'node-sqlparser'
2			import {Promise} from 'es6-promise'
3			import path from 'path'
4			import {
5			config,
6			Manager,
7			FileParser,
			0 ignored issues – show Unused Code introduced 2016-10-03 09:32 UTC by Report Bug Copy Issue Report The variable `FileParser` seems to be never used. Consider removing it. Loading history...
8			getAttr
9			} from '../../'
10
11			export function cleanRequest(str, jsonPage) {
			0 ignored issues – show Unused Code introduced 2016-10-04 12:44 UTC by Report Bug Copy Issue Report The parameter `jsonPage` is not used and could be removed. This check looks for parameters in functions that are not used in the function body and are not followed by other parameters which are used inside the function. Loading history...
12			var matchFrom = /from .(.*?) /
13			var matchVariable = /{{([a-zA-Z]*)}}/
14
15			var matchFromExec = matchFrom.exec(str)
16			if(typeof matchFromExec !== 'undefined' && matchFromExec !== null
17			&& typeof matchFromExec[1] !== 'undefined' && matchFromExec[1] !== null) {
18
19			var fromMatch
20			var toReplace = matchFromExec[1]
21			while (fromMatch = matchVariable.exec(toReplace)) {
22			try {
23			var value = eval('jsonPage.' + fromMatch[1])
			0 ignored issues – show Security Performance introduced 2016-09-27 10:32 UTC by Report Bug Copy Issue Report Calls to `eval` are slow and potentially dangerous, especially on untrusted code. Please consider whether there is another way to achieve your goal. Loading history...
24			if(typeof value !== 'undefined' && value !== null) {
25			toReplace = toReplace.replace('{{' + fromMatch[1] + '}}', value)
26			}else {
27			toReplace = toReplace.replace('{{' + fromMatch[1] + '}}', '')
28			}
29			}catch(e) {
			0 ignored issues – show Coding Style Comprehensibility Best Practice introduced 2016-09-30 14:19 UTC by Report Bug Copy Issue Report Empty catch clauses should be used with caution; consider adding a comment why this is needed. Loading history...
30			}
31			}
32
33			str = str.replace(matchFromExec[1], toReplace)
34			}
35
36			var from = /from ([\S\s]+)/.exec(str)

AdFabConnect / abejs

Push — master ( 2115c9...bdfcbe )

sql.js ➔ cleanRequest C

Complexity

Size

Duplication

Importance

How to fix Complexity

Complexity

Duplication Side-by-Side

Filter issues like